home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Skunkware 5
/
Skunkware 5.iso
/
man
/
cat.1
/
perlcall.1
< prev
next >
Wrap
Text File
|
1995-07-25
|
40KB
|
1,057 lines
PPPPEEEERRRRLLLLCCCCAAAALLLLLLLL((((1111)))) UUUUNNNNIIIIXXXX SSSSyyyysssstttteeeemmmm VVVV ((((RRRReeeelllleeeeaaaasssseeee 0000....0000 PPPPaaaattttcccchhhhlllleeeevvvveeeellll 00000000)))) PPPPEEEERRRRLLLLCCCCAAAALLLLLLLL((((1111))))
NNNNAAAAMMMMEEEE
perlcall - Perl calling conventions from C
DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNN
WWWWAAAARRRRNNNNIIIINNNNGGGG :::: TTTThhhhiiiissss ddddooooccccuuuummmmeeeennnntttt iiiissss ssssttttiiiillllllll uuuunnnnddddeeeerrrr ccccoooonnnnssssttttrrrruuuuccccttttiiiioooonnnn.... TTTThhhheeeerrrreeee
aaaarrrreeee bbbboooouuuunnnndddd ttttoooo bbbbeeee aaaa nnnnuuuummmmbbbbeeeerrrr ooooffff iiiinnnnaaaaccccccccuuuurrrraaaacccciiiieeeessss,,,, ssssoooo ttttrrrreeeeaaaadddd vvvveeeerrrryyyy
ccccaaaarrrreeeeffffuuuullllllllyyyy ffffoooorrrr nnnnoooowwww....
The purpose of this document is to show you how to write
_c_a_l_l_b_a_c_k_s, i.e. how to call Perl from C. The main focus is
on how to interface back to Perl from a bit of C code that
has itself been run by Perl, i.e. the 'main' program is a
Perl script; you are using it to execute a section of code
written in C; that bit of C code wants you to do something
with a particular event, so you want a Perl sub to be
executed whenever it happens.
Examples where this is necessary include
o+ You have created an XSUB interface to an application's
C API.
A fairly common feature in applications is to allow you
to define a C function that will get called whenever
something nasty occurs. What we would like is for a
Perl sub to be called instead.
o+ The classic example of where callbacks are used is in
an event driven program like for X-windows. In this
case your register functions to be called whenever a
specific events occur, e.g. a mouse button is pressed.
Although the techniques described are applicable to
embedding Perl in a C program, this is not the primary goal
of this document. For details on embedding Perl in C refer
to the _p_e_r_l_e_m_b_e_d manpage (currently unwritten).
Before you launch yourself head first into the rest of this
document, it would be a good idea to have read the following
two documents - the _p_e_r_l_a_p_i manpage and the _p_e_r_l_g_u_t_s
manpage.
This stuff is easier to explain using examples. But first
here are a few definitions anyway.
DDDDeeeeffffiiiinnnniiiittttiiiioooonnnnssss
Perl has a number of C functions which allow you to call
Perl subs. They are
Page 1 (printed 6/30/95)
PPPPEEEERRRRLLLLCCCCAAAALLLLLLLL((((1111)))) UUUUNNNNIIIIXXXX SSSSyyyysssstttteeeemmmm VVVV ((((RRRReeeelllleeeeaaaasssseeee 0000....0000 PPPPaaaattttcccchhhhlllleeeevvvveeeellll 00000000)))) PPPPEEEERRRRLLLLCCCCAAAALLLLLLLL((((1111))))
I32 perl_call_sv(SV* sv, I32 flags) ;
I32 perl_call_pv(char *subname, I32 flags) ;
I32 perl_call_method(char *methname, I32 flags) ;
I32 perl_call_argv(char *subname, I32 flags, register char **argv) ;
The key function is _p_e_r_l__c_a_l_l__s_v. All the other functions
make use of _p_e_r_l__c_a_l_l__s_v to do what they do.
_p_e_r_l__c_a_l_l__s_v takes two parameters, the first is an SV*. This
allows you to specify the Perl sub to be called either as a
C string (which has first been converted to an SV) or a
reference to a sub. Example 7, shows you how you can make
use of _p_e_r_l__c_a_l_l__s_v. The second parameter, flags, is a
general purpose option command. This parameter is common to
all the _p_e_r_l__c_a_l_l_* functions. It is discussed in the next
section.
The function, _p_e_r_l__c_a_l_l__p_v, is similar as _p_e_r_l__c_a_l_l__s_v
except it expects it's first parameter has to be a C char*
which identifies the Perl sub you want to call, e.g.
perl_call_pv("fred", 0).
The function _p_e_r_l__c_a_l_l__m_e_t_h_o_d expects its first argument to
contain a blessed reference to a class. Using that reference
it looks up and calls methname from that class. See example
9.
_p_e_r_l__c_a_l_l__a_r_g_v calls the Perl sub specified by the subname
parameter. It also takes the usual flags parameter. The
final parameter, argv, consists of a list of C strings to be
sent to the Perl sub. See example 8.
All the functions return a number. This is a count of the
number of items returned by the Perl sub on the stack.
As a general rule you should _a_l_w_a_y_s check the return value
from these functions. Even if you are only expecting a
particular number of values to be returned from the Perl
sub, there is nothing to stop someone from doing something
unexpected - don't say you havn't been warned.
FFFFllllaaaagggg VVVVaaaalllluuuueeeessss
The flags parameter in all the _p_e_r_l__c_a_l_l_* functions
consists of any combination of the symbols defined below,
OR'ed together.
G_SCALAR
Calls the Perl sub in a scalar context.
Whatever the Perl sub actually returns, we only want a
scalar. If the perl sub does return a scalar, the
Page 2 (printed 6/30/95)
PPPPEEEERRRRLLLLCCCCAAAALLLLLLLL((((1111)))) UUUUNNNNIIIIXXXX SSSSyyyysssstttteeeemmmm VVVV ((((RRRReeeelllleeeeaaaasssseeee 0000....0000 PPPPaaaattttcccchhhhlllleeeevvvveeeellll 00000000)))) PPPPEEEERRRRLLLLCCCCAAAALLLLLLLL((((1111))))
return value from the _p_e_r_l__c_a_l_l_* function will be 1 or
0. If 1, then the value actually returned by the Perl
sub will be contained on the top of the stack. If 0,
then the sub has probably called _d_i_e or you have used
the G_DISCARD flag.
If the Perl sub returns a list, the _p_e_r_l__c_a_l_l_*
function will still only return 1 or 0. If 1, then the
number of elements in the list will be stored on top of
the stack. The actual values of the list will not be
accessable.
G_SCALAR is the default flag setting for all the
functions.
G_ARRAY
Calls the Perl sub in a list context.
The return code from the _p_e_r_l__c_a_l_l_* functions will
indicate how many elements of the stack are used to
store the array.
G_DISCARD
If you are not interested in the values returned by the
Perl sub then setting this flag will make Perl get rid
of them automatically for you. This will take
precedence to either G_SCALAR or G_ARRAY.
If you do not set this flag then you may need to
explicitly get rid of temporary values. See example 3
for details.
G_NOARGS
If you are not passing any parameters to the Perl sub,
you can save a bit of time by setting this flag. It has
the effect of of not creating the @_ array for the Perl
sub.
A point worth noting is that if this flag is specified
the Perl sub called can still access an @_ array from a
previous Perl sub. This functionality can be
illustrated with the perl code below
sub fred
{ print "@_\n" }
sub joe
{ &fred }
&joe(1,2,3) ;
This will print
Page 3 (printed 6/30/95)
PPPPEEEERRRRLLLLCCCCAAAALLLLLLLL((((1111)))) UUUUNNNNIIIIXXXX SSSSyyyysssstttteeeemmmm VVVV ((((RRRReeeelllleeeeaaaasssseeee 0000....0000 PPPPaaaattttcccchhhhlllleeeevvvveeeellll 00000000)))) PPPPEEEERRRRLLLLCCCCAAAALLLLLLLL((((1111))))
1 2 3
What has happened is that fred accesses the @_ array
which belongs to joe.
G_EVAL
If the Perl sub you are calling has the ability to
terminate abnormally, e.g. by calling _d_i_e or by not
actually existing, and you want to catch this type of
event, specify this flag setting. It will put an _e_v_a_l {
} around the sub call.
Whenever control returns from the _p_e_r_l__c_a_l_l_* function
you need to check the $@ variable as you would in a
normal Perl script. See example 6 for details of how to
do this.
EEEEXXXXAAAAMMMMPPPPLLLLEEEESSSS
Enough of the definition talk, let's have a few examples.
Perl provides many macros to assist in accessing the Perl
stack. These macros should always be used when interfacing
to Perl internals. Hopefully this should make the code less
vulnerable to changes made to Perl in the future.
Another point worth noting is that in the first series of
examples I have only made use of the _p_e_r_l__c_a_l_l__p_v function.
This has only been done to ease you into the topic. Wherever
possible, if the choice is between using _p_e_r_l__c_a_l_l__p_v and
_p_e_r_l__c_a_l_l__s_v, I would always try to use _p_e_r_l__c_a_l_l__s_v.
The code for these examples is stored in the file
_p_e_r_l_c_a_l_l._t_a_r. (Once this document settles down, all the
example code will be available in the file).
EEEExxxxaaaammmmpppplllleeee1111:::: NNNNoooo PPPPaaaarrrraaaammmmeeeetttteeeerrrrssss,,,, NNNNooootttthhhhiiiinnnngggg rrrreeeettttuuuurrrrnnnneeeedddd
This first trivial example will call a Perl sub, _P_r_i_n_t_U_I_D,
to print out the UID of the process.
sub PrintUID
{
print "UID is $<\n" ;
}
and here is the C to call it
void
call_PrintUID()
{
dSP ;
Page 4 (printed 6/30/95)
PPPPEEEERRRRLLLLCCCCAAAALLLLLLLL((((1111)))) UUUUNNNNIIIIXXXX SSSSyyyysssstttteeeemmmm VVVV ((((RRRReeeelllleeeeaaaasssseeee 0000....0000 PPPPaaaattttcccchhhhlllleeeevvvveeeellll 00000000)))) PPPPEEEERRRRLLLLCCCCAAAALLLLLLLL((((1111))))
PUSHMARK(sp) ;
perl_call_pv("PrintUID", G_DISCARD|G_NOARGS) ;
}
Simple, eh.
A few points to note about this example.
1. We aren't passing any parameters to _P_r_i_n_t_U_I_D so
G_NOARGS can be specified.
2. Ignore dSP and PUSHMARK(sp) for now. They will be
discussed in the next example.
3. We aren't interested in anything returned from
_P_r_i_n_t_U_I_D, so G_DISCARD is specified. Even if _P_r_i_n_t_U_I_D
was changed to actually return some _v_a_l_u_e(s), having
specified G_DISCARD will mean that they will be wiped
by the time control returns from _p_e_r_l__c_a_l_l__p_v.
4. Because we specified G_DISCARD, it is not necessary to
check the value returned from _p_e_r_l__c_a_l_l__s_v. It will
always be 0.
5. As _p_e_r_l__c_a_l_l__p_v is being used, the Perl sub is
specified as a C string.
EEEExxxxaaaammmmpppplllleeee 2222:::: PPPPaaaassssssssiiiinnnngggg PPPPaaaarrrraaaammmmeeeetttteeeerrrrssss
Now let's make a slightly more complex example. This time we
want to call a Perl sub which will take 2 parameters - a
string ($s) and an integer ($n). The sub will simply print
the first $n characters of the string.
So the Perl sub would look like this
sub LeftString
{
my($s, $n) = @_ ;
print substr($s, 0, $n), "\n" ;
}
The C function required to call _L_e_f_t_S_t_r_i_n_g would look like
this.
static void
call_LeftString(a, b)
char * a ;
int b ;
{
dSP ;
Page 5 (printed 6/30/95)
PPPPEEEERRRRLLLLCCCCAAAALLLLLLLL((((1111)))) UUUUNNNNIIIIXXXX SSSSyyyysssstttteeeemmmm VVVV ((((RRRReeeelllleeeeaaaasssseeee 0000....0000 PPPPaaaattttcccchhhhlllleeeevvvveeeellll 00000000)))) PPPPEEEERRRRLLLLCCCCAAAALLLLLLLL((((1111))))
PUSHMARK(sp) ;
XPUSHs(sv_2mortal(newSVpv(a, 0)));
XPUSHs(sv_2mortal(newSViv(b)));
PUTBACK ;
perl_call_pv("LeftString", G_DISCARD);
}
Here are a few notes on the C function _c_a_l_l__L_e_f_t_S_t_r_i_n_g.
1. The only flag specified this time is G_DISCARD. As we
are passing 2 parameters to the Perl sub this time, we
have not specified G_NOARGS.
2. Parameters are passed to the Perl sub using the Perl
stack. This is the purpose of the code beginning with
the line dSP and ending with the line PUTBACK.
3. If you are going to put something onto the Perl stack,
you need to know where to put it. This is the purpose
of the macro dSP - it declares and initialises a local
copy of the Perl stack pointer.
All the other macros which will be used in this example
require you to have used this macro.
If you are calling a Perl sub directly from an XSUB
function, it is not necessary to explicitly use the dSP
macro - it will be declared for you.
4. Any parameters to be pushed onto the stack should be
bracketed by the PUSHMARK and PUTBACK macros. The
purpose of these two macros, in this context, is to
automatically count the number of parameters you are
pushing. Then whenever Perl is creating the @_ array
for the sub, it knows how big to make it.
The PUSHMARK macro tells Perl to make a mental note of
the current stack pointer. Even if you aren't passing
any parameters (like in Example 1) you must still call
the PUSHMARK macro before you can call any of the
_p_e_r_l__c_a_l_l_* functions - Perl still needs to know that
there are no parameters.
The PUTBACK macro sets the global copy of the stack
pointer to be the same as our local copy. If we didn't
do this _p_e_r_l__c_a_l_l__p_v wouldn't know where the two
parameters we pushed were - remember that up to now all
the stack pointer manipulation we have done is with our
local copy, _n_o_t the global copy.
Page 6 (printed 6/30/95)
PPPPEEEERRRRLLLLCCCCAAAALLLLLLLL((((1111)))) UUUUNNNNIIIIXXXX SSSSyyyysssstttteeeemmmm VVVV ((((RRRReeeelllleeeeaaaasssseeee 0000....0000 PPPPaaaattttcccchhhhlllleeeevvvveeeellll 00000000)))) PPPPEEEERRRRLLLLCCCCAAAALLLLLLLL((((1111))))
5. Next, we come to XPUSHs. This is where the parameters
actually get pushed onto the stack. In this case we are
pushing a string and an integer.
See the section _X_S_U_B'_s _A_N_D _T_H_E _A_R_G_U_M_E_N_T _S_T_A_C_K in the
_p_e_r_l_g_u_t_s manpage for details on how the XPUSH macros
work.
6. Finally, _L_e_f_t_S_t_r_i_n_g can now be called via the
_p_e_r_l__c_a_l_l__p_v function.
EEEExxxxaaaammmmpppplllleeee 3333:::: RRRReeeettttuuuurrrrnnnniiiinnnngggg aaaa SSSSccccaaaallllaaaarrrr
Now for an example of dealing with the values returned from
a Perl sub.
Here is a Perl sub, _A_d_d_e_r, which takes 2 integer parameters
and simply returns their sum.
sub Adder
{
my($a, $b) = @_ ;
$a + $b ;
}
As we are now concerned with the return value from _A_d_d_e_r,
the C function is now a bit more complex.
static void
call_Adder(a, b)
int a ;
int b ;
{
dSP ;
int count ;
ENTER ;
SAVETMPS;
PUSHMARK(sp) ;
XPUSHs(sv_2mortal(newSViv(a)));
XPUSHs(sv_2mortal(newSViv(b)));
PUTBACK ;
count = perl_call_pv("Adder", G_SCALAR);
SPAGAIN ;
if (count != 1)
croak("Big trouble\n") ;
printf ("The sum of %d and %d is %d\n", a, b, POPi) ;
Page 7 (printed 6/30/95)
PPPPEEEERRRRLLLLCCCCAAAALLLLLLLL((((1111)))) UUUUNNNNIIIIXXXX SSSSyyyysssstttteeeemmmm VVVV ((((RRRReeeelllleeeeaaaasssseeee 0000....0000 PPPPaaaattttcccchhhhlllleeeevvvveeeellll 00000000)))) PPPPEEEERRRRLLLLCCCCAAAALLLLLLLL((((1111))))
PUTBACK ;
FREETMPS ;
LEAVE ;
}
Points to note this time are
1. The only flag specified this time was G_SCALAR. That
means the @_ array will be created and that the value
returned by _A_d_d_e_r will still exist after the call to
_p_e_r_l__c_a_l_l__p_v.
2. Because we are interested in what is returned from
_A_d_d_e_r we cannot specify G_DISCARD. This means that we
will have to tidy up the Perl stack and dispose of any
temporary values ourselves. This is the purpose of
ENTER ;
SAVETMPS ;
at the start of the function, and
FREETMPS ;
LEAVE ;
at the end. The ENTER/SAVETMPS pair creates a boundary
for any temporaries we create. This means that the
temporaries we get rid of will be limited to those
which were created after these calls.
The FREETMPS/LEAVE pair will get rid of any values
returned by the Perl sub, plus it will also dump the
mortal SV's we created. Having ENTER/SAVETMPS at the
beginning of the code makes sure that no other mortals
are destroyed.
3. The purpose of the macro SPAGAIN is to refresh the
local copy of the stack pointer. This is necessary
because it is possible that the memory allocated to the
Perl stack has been re-allocated whilst in the
_p_e_r_l__c_a_l_l__p_v call.
If you are making use of the Perl stack pointer in your
code you must always refresh the your local copy using
SPAGAIN whenever you make use of of the _p_e_r_l__c_a_l_l_*
functions or any other Perl internal function.
4. Although only a single value was expected to be
returned from _A_d_d_e_r, it is still good practice to check
the return code from _p_e_r_l__c_a_l_l__p_v anyway.
Expecting a single value is not quite the same as
Page 8 (printed 6/30/95)
PPPPEEEERRRRLLLLCCCCAAAALLLLLLLL((((1111)))) UUUUNNNNIIIIXXXX SSSSyyyysssstttteeeemmmm VVVV ((((RRRReeeelllleeeeaaaasssseeee 0000....0000 PPPPaaaattttcccchhhhlllleeeevvvveeeellll 00000000)))) PPPPEEEERRRRLLLLCCCCAAAALLLLLLLL((((1111))))
knowing that there will be one. If someone modified
_A_d_d_e_r to return a list and we didn't check for that
possibility and take appropriate action the Perl stack
would end up in an inconsistant state. That is
something you _r_e_a_l_l_y don't want to ever happen.
5. The POPi macro is used here to pop the return value
from the stack. In this case we wanted an integer, so
POPi was used.
Here is the complete list of POP macros available,
along with the types they return.
POPs SV
POPp pointer
POPn double
POPi integer
POPl long
6. The final PUTBACK is used to leave the Perl stack in a
consistant state before exiting the function. This is
necessary because when we popped the return value from
the stack with POPi it only updated our local copy of
the stack pointer. Remember, PUTBACK sets the global
stack pointer to be the same as our local copy.
EEEExxxxaaaammmmpppplllleeee 4444:::: RRRReeeettttuuuurrrrnnnniiiinnnngggg aaaa lllliiiisssstttt ooooffff vvvvaaaalllluuuueeeessss
Now, let's extend the previous example to return both the
sum of the parameters and the difference.
Here is the Perl sub
sub AddSubtract
{
my($a, $b) = @_ ;
($a+$b, $a-$b) ;
}
and this is the C function
static void
call_AddSubtract(a, b)
int a ;
int b ;
{
dSP ;
int count ;
ENTER ;
SAVETMPS;
Page 9 (printed 6/30/95)
PPPPEEEERRRRLLLLCCCCAAAALLLLLLLL((((1111)))) UUUUNNNNIIIIXXXX SSSSyyyysssstttteeeemmmm VVVV ((((RRRReeeelllleeeeaaaasssseeee 0000....0000 PPPPaaaattttcccchhhhlllleeeevvvveeeellll 00000000)))) PPPPEEEERRRRLLLLCCCCAAAALLLLLLLL((((1111))))
PUSHMARK(sp) ;
XPUSHs(sv_2mortal(newSViv(a)));
XPUSHs(sv_2mortal(newSViv(b)));
PUTBACK ;
count = perl_call_pv("AddSubtract", G_ARRAY);
SPAGAIN ;
if (count != 2)
croak("Big trouble\n") ;
printf ("%d - %d = %d\n", a, b, POPi) ;
printf ("%d + %d = %d\n", a, b, POPi) ;
PUTBACK ;
FREETMPS ;
LEAVE ;
}
Notes
1. We wanted array context, so we used G_ARRAY.
2. Not surprisingly there are 2 POPi's this time because
we were retrieving 2 values from the stack. The main
point to note is that they came off the stack in
reverse order.
EEEExxxxaaaammmmpppplllleeee 5555:::: RRRReeeettttuuuurrrrnnnniiiinnnngggg DDDDaaaattttaaaa ffffrrrroooommmm PPPPeeeerrrrllll vvvviiiiaaaa tttthhhheeee ppppaaaarrrraaaammmmeeeetttteeeerrrr lllliiiisssstttt
It is also possible to return values directly via the
parameter list - whether it is actually desirable to do it
is another matter entirely.
The Perl sub, _I_n_c, below takes 2 parameters and increments
each.
sub Inc
{
++ $_[0] ;
++ $_[1] ;
}
and here is a C function to call it.
Page 10 (printed 6/30/95)
PPPPEEEERRRRLLLLCCCCAAAALLLLLLLL((((1111)))) UUUUNNNNIIIIXXXX SSSSyyyysssstttteeeemmmm VVVV ((((RRRReeeelllleeeeaaaasssseeee 0000....0000 PPPPaaaattttcccchhhhlllleeeevvvveeeellll 00000000)))) PPPPEEEERRRRLLLLCCCCAAAALLLLLLLL((((1111))))
static void
call_Inc(a, b)
int a ;
int b ;
{
dSP ;
int count ;
SV * sva ;
SV * svb ;
ENTER ;
SAVETMPS;
sva = sv_2mortal(newSViv(a)) ;
svb = sv_2mortal(newSViv(b)) ;
PUSHMARK(sp) ;
XPUSHs(sva);
XPUSHs(svb);
PUTBACK ;
count = perl_call_pv("Inc", G_DISCARD);
if (count != 0)
croak ("call_Inc : expected 0 return value from 'Inc', got %d\n", count) ;
printf ("%d + 1 = %d\n", a, SvIV(sva)) ;
printf ("%d + 1 = %d\n", b, SvIV(svb)) ;
FREETMPS ;
LEAVE ;
}
To be able to access the two parameters that were pushed
onto the stack after they return from _p_e_r_l__c_a_l_l__p_v it is
necessary to make a note of their addresses - thus the two
variables sva and svb.
The reason this is necessary is that the area of the Perl
stack which held them will very likely have been overwritten
by something else by the time control returns from
_p_e_r_l__c_a_l_l__p_v.
EEEExxxxaaaammmmpppplllleeee 6666:::: UUUUssssiiiinnnngggg GGGG____EEEEVVVVAAAALLLL
Now an example using G_EVAL. Below is a Perl sub which
computes the difference of its 2 parameters. If this would
result in a negative result, the sub calls _d_i_e.
sub Subtract
{
my ($a, $b) = @_ ;
Page 11 (printed 6/30/95)
PPPPEEEERRRRLLLLCCCCAAAALLLLLLLL((((1111)))) UUUUNNNNIIIIXXXX SSSSyyyysssstttteeeemmmm VVVV ((((RRRReeeelllleeeeaaaasssseeee 0000....0000 PPPPaaaattttcccchhhhlllleeeevvvveeeellll 00000000)))) PPPPEEEERRRRLLLLCCCCAAAALLLLLLLL((((1111))))
die "death can be fatal\n" if $a < $b ;
$a - $b ;
}
and some C to call it
static void
call_Subtract(a, b)
int a ;
int b ;
{
dSP ;
int count ;
SV * sv ;
ENTER ;
SAVETMPS;
PUSHMARK(sp) ;
XPUSHs(sv_2mortal(newSViv(a)));
XPUSHs(sv_2mortal(newSViv(b)));
PUTBACK ;
count = perl_call_pv("Subtract", G_EVAL|G_SCALAR);
/* Check the eval first */
sv = GvSV(gv_fetchpv("@", TRUE, SVt_PV));
if (SvTRUE(sv))
printf ("Uh oh - %s\n", SvPV(sv, na)) ;
SPAGAIN ;
if (count != 1)
croak ("call_Subtract : expected 1 return value from 'Subtract', got %d\n", count) ;
printf ("%d - %d = %d\n", a, b, POPi) ;
PUTBACK ;
FREETMPS ;
LEAVE ;
}
If _c_a_l_l__S_u_b_t_r_a_c_t is called thus
call_Subtract(4, 5)
the following will be printed
Uh oh - death can be fatal
Page 12 (printed 6/30/95)
PPPPEEEERRRRLLLLCCCCAAAALLLLLLLL((((1111)))) UUUUNNNNIIIIXXXX SSSSyyyysssstttteeeemmmm VVVV ((((RRRReeeelllleeeeaaaasssseeee 0000....0000 PPPPaaaattttcccchhhhlllleeeevvvveeeellll 00000000)))) PPPPEEEERRRRLLLLCCCCAAAALLLLLLLL((((1111))))
Notes
1. We want to be able to catch the _d_i_e so we have used the
G_EVAL flag. Not specifying this flag would mean that
the program would terminate.
2. The code
sv = GvSV(gv_fetchpv("@", TRUE, SVt_PV));
if (SvTRUE(sv))
printf ("Uh oh - %s\n", SvPVx(sv, na)) ;
is the equivalent of this bit of Perl
print "Uh oh - $@\n" if $@ ;
EEEExxxxaaaammmmpppplllleeee 7777:::: UUUUssssiiiinnnngggg ppppeeeerrrrllll____ccccaaaallllllll____ssssvvvv
In all the previous examples I have 'hard-wried' the name of
the Perl sub to be called from C. Sometimes though, it is
necessary to be able to specify the name of the Perl sub
from within the Perl script.
Consider the Perl code below
sub fred
{
print "Hello there\n" ;
}
CallSub("fred") ;
here is a snippet of XSUB which defines _C_a_l_l_S_u_b.
void
CallSub(name)
char * name
CODE:
PUSHMARK(sp) ;
perl_call_pv(name, G_DISCARD|G_NOARGS) ;
That is fine as far as it goes. The thing is, it only allows
the Perl sub to be specified as a string. For perl 4 this
was adequate, but Perl 5 allows references to subs and
anonymous subs. This is where _p_e_r_l__c_a_l_l__s_v is useful.
The code below for _C_a_l_l_S_u_b is identical to the previous time
except that the name parameter is now defined as an SV* and
we use _p_e_r_l__c_a_l_l__s_v instead of _p_e_r_l__c_a_l_l__p_v.
Page 13 (printed 6/30/95)
PPPPEEEERRRRLLLLCCCCAAAALLLLLLLL((((1111)))) UUUUNNNNIIIIXXXX SSSSyyyysssstttteeeemmmm VVVV ((((RRRReeeelllleeeeaaaasssseeee 0000....0000 PPPPaaaattttcccchhhhlllleeeevvvveeeellll 00000000)))) PPPPEEEERRRRLLLLCCCCAAAALLLLLLLL((((1111))))
void
CallSub(name)
SV* name
CODE:
PUSHMARK(sp) ;
perl_call_sv(name, G_DISCARD|G_NOARGS) ;
As we are using an SV to call _f_r_e_d the following can all be
used
CallSub("fred") ;
Callsub(\&fred) ;
$ref = \&fred ;
CallSub($ref) ;
CallSub( sub { print "Hello there\n" } ) ;
As you can see, _p_e_r_l__c_a_l_l__s_v gives you greater flexibility
in how you can specify the Perl sub.
EEEExxxxaaaammmmpppplllleeee 8888:::: UUUUssssiiiinnnngggg ppppeeeerrrrllll____ccccaaaallllllll____aaaarrrrggggvvvv
Here is a Perl sub which prints whatever parameters are
passed to it.
sub PrintList
{
my(@list) = @_ ;
foreach (@list) { print "$_\n" }
}
and here is an example of _p_e_r_l__c_a_l_l__a_r_g_v which will call
_P_r_i_n_t_L_i_s_t.
call_PrintList
{
dSP ;
char * words[] = {"alpha", "beta", "gamma", "delta", NULL } ;
perl_call_argv("PrintList", words, G_DISCARD) ;
}
Note that it is not necessary to call PUSHMARK in this
instance. This is because _p_e_r_l__c_a_l_l__a_r_g_v will do it for you.
EEEExxxxaaaammmmpppplllleeee 9999:::: UUUUssssiiiinnnngggg ppppeeeerrrrllll____ccccaaaallllllll____mmmmeeeetttthhhhoooodddd
[This section is under construction]
Consider the following Perl code
Page 14 (printed 6/30/95)
PPPPEEEERRRRLLLLCCCCAAAALLLLLLLL((((1111)))) UUUUNNNNIIIIXXXX SSSSyyyysssstttteeeemmmm VVVV ((((RRRReeeelllleeeeaaaasssseeee 0000....0000 PPPPaaaattttcccchhhhlllleeeevvvveeeellll 00000000)))) PPPPEEEERRRRLLLLCCCCAAAALLLLLLLL((((1111))))
{
package Mine ;
sub new { bless [@_] }
sub Display { print $_[0][1], "\n" }
}
$a = new Mine ('red', 'green', 'blue') ;
call_Display($a, 'Display') ;
The method Display just prints out the first element of the
list. Here is a XSUB implementation of _c_a_l_l__D_i_s_p_l_a_y.
void
call_Display(ref, method)
SV * ref
char * method
CODE:
PUSHMARK(sp);
XPUSHs(ref);
PUTBACK;
perl_call_method(method, G_DISCARD) ;
SSSSttttrrrraaaatttteeeeggggiiiieeeessss ffffoooorrrr ssssttttoooorrrriiiinnnngggg CCCCoooonnnntttteeeexxxxtttt IIIInnnnffffoooorrrrmmmmaaaattttiiiioooonnnn
[This section is under construction]
One of the trickiest problems to overcome when designing a
callback interface is figuring out how to store the mapping
between the C callback functions and the Perl equivalent.
Consider the following example.
AAAAlllltttteeeerrrrnnnnaaaatttteeee SSSSttttaaaacccckkkk MMMMaaaannnniiiippppuuuullllaaaattttiiiioooonnnn
[This section is under construction]
Although I have only made use of the POP* macros to access
values returned from Perl subs, it is also possible to
bypass these macros and read the stack directly.
The code below is example 4 recoded to
SSSSEEEEEEEE AAAALLLLSSSSOOOO
the _p_e_r_l_a_p_i manpage, the _p_e_r_l_g_u_t_s manpage, the _p_e_r_l_e_m_b_e_d
manpage
AAAAUUUUTTTTHHHHOOOORRRR
Paul Marquess <pmarquess@bfsec.bt.co.uk>
Page 15 (printed 6/30/95)
PPPPEEEERRRRLLLLCCCCAAAALLLLLLLL((((1111)))) UUUUNNNNIIIIXXXX SSSSyyyysssstttteeeemmmm VVVV ((((RRRReeeelllleeeeaaaasssseeee 0000....0000 PPPPaaaattttcccchhhhlllleeeevvvveeeellll 00000000)))) PPPPEEEERRRRLLLLCCCCAAAALLLLLLLL((((1111))))
Special thanks to the following people who assisted in the
creation of the document.
Jeff Okamoto, Tim Bunce.
DDDDAAAATTTTEEEE
Version 0.4, 17th October 1994
Page 16 (printed 6/30/95)